package rpg.desafio;

import rpg.personagem.Mensageiro;
import rpg.personagem.Personagem;
import rpg.recurso.Recurso;

/**
 *
 * @author Eduardo Bruning
 *
 */
public class Desafio {

    private Mensageiro mensageiro;
    /**
     * Método contrutor
     * @param mensageiro do tipo Mensageiro, para colocar o mensageiro no desafio 
     */
    public Desafio(Mensageiro mensageiro){
        this.mensageiro = mensageiro;
    }
    
/** Explicando o método Confronto...
 * Este método recebe como parâmetro um mensageiro, um inimigo do tipo Personagem, uma string escolha que seria 
 * o que o usuário digitou e dois int, que serão os inteiros para os métodos golpear, defender e correr, no qual
 * esse inteiro é o numero para um radom sendo que o do mensageiro deve ser maior para o mensageiro ter mais chance
 * de seguir em frente no jogo.
 * Em resumo o método primeiro testa se o inimigo tem vida diferente de 0, se sim o usuário faz a escolha de lutar ou correr
 * se a escolha for lutar, o mensageiro começa atacando e faz uma comparação do golpear do mensageiro com o defender do inimigo
 * se o golpear for maior que o defender e inimigo perde além do desgaste de defender o golpe mais 5 de vida, caso contrario 
 * o mensageiro perde 5 de vida além do desgaste de atacar e se for iguais o golpear e o defender ambos perdem 5 de vida
 * após isso é o inimigo que faz o ataque e segue os mesmo critérios do ataque do mensageiro, ele vai seguir fazendo isto até
 * que um dos personagens morra, ou seja, quando a vida de um deles for igual a 0.
 * Se ele escolher correr serão testados os métodos correr de um com o do outro, quem tiver o maior mata o outro, ou seja,
 * se o mensageiro tiver o correr maior que o do inimigo ele consegue seguir em frente, porém perde vida por correr, caso contrario
 * o inimigo mata o mensageiro, se eles forem iguais, os correr, começa um luta igual ao explicado a cima.
 * @param inimigo do tipo Personagem, parametro pra colocar o inimigo na qual o personagem irá enfrentar 
 * @param escolha do tipo int, recede o numero 1 ou 2 para saber se o mensageiro deseja lutar ou correr 
 * @param numeroInimigo do tipo int, um inteiro para utilizar no metodo golpear para o random, assim sortea um numero que 
 * será multiplicado pela força do inimigo
 * @param numeroMensageiro  do tipo int, um inteiro para utilizar no metodo golpear para o random, assim sortea um numero que 
 * será multiplicado pela força do mensageiro
 */
    
    public boolean Confronto(Personagem inimigo, int escolha, int numeroMensageiro, int numeroInimigo) {

        boolean retorno = false;
        if (inimigo != null) {

            switch (escolha) {
                case 1:
                    while (inimigo.getVida() == 0 || getMensageiro().getVida() == 0){
                        if (getMensageiro().golpear(numeroMensageiro) > inimigo.defender(numeroInimigo)) {
                            inimigo.atualizarVida(-5);
                        } else if (getMensageiro().golpear(numeroMensageiro) == inimigo.defender(numeroInimigo)) {
                            inimigo.atualizarVida(-5);
                            getMensageiro().atualizarVida(- 5);
                        } else {
                            getMensageiro().atualizarVida(- 5);
                        }

                        if (inimigo.golpear(numeroInimigo) > getMensageiro().defender(numeroMensageiro)) {
                            getMensageiro().atualizarVida(- 5);
                        } else if (inimigo.golpear(numeroInimigo) == getMensageiro().defender(numeroMensageiro)) {
                            inimigo.atualizarVida(-5);
                            getMensageiro().atualizarVida(-5);
                        } else {
                            inimigo.atualizarVida(- 5);
                        }
                    } 
                    
                    if (getMensageiro().getVida() != 0) {
                        retorno = true;
                        inimigo = null;
                    }else if(getMensageiro().getVida() == 0 && inimigo.getVida() ==0){
                    mensageiro.atualizarVida(0);
                    inimigo = null;
                    retorno = false;
                    }else{
                        mensageiro.atualizarVida(0);
                        retorno = false;
                    }
                    break;


                case 2:
                    if (getMensageiro().fugirCombate(numeroMensageiro) > inimigo.fugirCombate(numeroInimigo)) {
                    retorno = true;
                    } else if (getMensageiro().fugirCombate(numeroMensageiro) == inimigo.fugirCombate(numeroInimigo)) {
                        Confronto(inimigo, 1, numeroMensageiro, numeroInimigo);
                    } else {
                        mensageiro.atualizarVida(0);
                        retorno = false;
                    }
            break;
            }
        } else {
        retorno = true;
        }
        return retorno;
    }



    
    /**
     * Explicando o método necessitaRecursos
     * tem como parâmetro um recurso para fazer a comparação com o vetor de recursos do personagem
     * se o personagem tem o recurso que necessita, ou seja, se o recurso do parâmetro do método for igual
     * ao do vetor em alguma de suas posições o método retorna true e deixa o recurso indisponivél, caso contrário
     * retorna false.
     * @param recursonecessario do tipo Recurso, colocado o recurso que deseja saber o o personagem possui
     */
    public boolean necessitaRecurso(Recurso recursonecessario){
       
        boolean retorno= true;
       if (mensageiro.getRecursos() != null) {
            for (int i = 0; i < getMensageiro().getRecursos().size(); i++) {
            if (mensageiro.getRecursos().get(i) == recursonecessario) {
            mensageiro.usarItem(recursonecessario);
            retorno =true;
            break;
            }else{
            retorno = false;
        }
        }    
      }else{
        retorno = false;  
       }  
        return retorno;
    }

    public Mensageiro getMensageiro() {
        return mensageiro;
    }

    public void setMensageiro(Mensageiro mensageiro) {
        this.mensageiro = mensageiro;
    }
}
